package org.stvd.core.util;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

import org.springframework.security.authentication.encoding.Md5PasswordEncoder;
import org.springframework.security.authentication.encoding.PasswordEncoder;
import org.stvd.core.jdbc.sequence.SequenceUtil;

public class StringUtil {
    /**
     * 创建正则表达式的方法，采用常用的形式
     * 
     * @author
     * @param strRegex
     *            通常习惯书写的正则表达式，如"^\\d+\\w."等，注意要用两条斜杠。
     * @param flagCase
     *            是否区分大小写。0 不区分，1 区分， 默认区分大小写。另外，此方法默认了多行匹配。
     */
    public static final Pattern createPattern(String strRegex, int flagCase) {
        Pattern patternRegex = null;
        if (flagCase == 0) {
            patternRegex = Pattern.compile(strRegex, Pattern.MULTILINE | Pattern.CASE_INSENSITIVE);
        } else {
            patternRegex = Pattern.compile(strRegex, Pattern.MULTILINE);
        }
        return patternRegex;
    }

    /**
     * 使用正则表达式检查某字串是否匹配表达式的方法
     * 
     * @author
     * @return 返回是否匹配正则表达式。
     * @param strBeChecked
     *            被检查的字符串。
     * @param strRegex
     *            传入的正则表达式字符串，如："\\(\\d{3}\\)\\s\\d{3}-\\d{4}";
     * @param flagCase
     *            是否区分大小写。0 不区分，1 区分， 默认区分大小写。 flags Match flags, a bit mask
     *            that may include {@link #CASE_INSENSITIVE}, {@link #MULTILINE}
     *            , {@link #DOTALL}, {@link #UNICODE_CASE}, and
     *            {@link #CANON_EQ}
     */
    public static final boolean checkMatchRegex(String strBeChecked, String strRegex, int flagCase) {
        Pattern patternRegex = createPattern(strRegex, flagCase);
        Matcher m = patternRegex.matcher(strBeChecked);
        return m.find();
    }

    /**
     * 使用正则表达式替换某字串中匹配表达式的部分的方法
     * 
     * @author
     * @return 返回替换后的字串。
     * @param strBeReplaced
     *            被检查的字符串。
     * @param strRegex
     *            传入的正则表达式字符串，如："\\(\\d{3}\\)\\s\\d{3}-\\d{4}";
     * @param flagCase
     *            是否区分大小写。0 不区分，1 区分， 默认区分大小写。
     * @param strChange
     *            替换的字串。
     */
    public static final String replaceMatchRegex(String strBeChecked, String strRegex, int flagCase, String strChange) {
        Pattern patternRegex = createPattern(strRegex, flagCase);
        Matcher m = patternRegex.matcher(strBeChecked);
        return m.replaceAll(strChange);
    }

    public static final String subMatchRegex(String strBeMatch, String strRegex, int falgCase) {
        Pattern pattern = StringUtil.createPattern(strRegex, falgCase);
        Matcher matcher = pattern.matcher(strBeMatch);
        StringBuffer buffer = new StringBuffer();
        while (matcher.find()) {
            buffer.append(matcher.group());
        }
        return buffer.toString();
    }

    /**
     * 截取字符串中的子串
     * 
     * @param str
     *            需要截取的字符串
     * @param startNum
     *            截取字符串的起始位置 当startNum = -1时，表示倒序截取该字符串的最后cutNum位 当startNum >
     *            0时，表示顺序截取该字符串前cutNum位(索引值从1开始)
     * @param cutNum
     *            截取字符串的个数
     * @return
     */
    public static final String subString(String str, int startNum, int cutNum) {
        int start = startNum;
        int cut = cutNum;
        if (start > 0) {
            start = start - 1;
            if (start <= str.length() && str.length() <= (start + cut)) {
                return str.substring(start, str.length());
            } else if (str.length() > (start + cut)) {
                return str.substring(start, start + cut);
            } else {
                return "";
            }
        } else {
            start = str.length() - cut;
            if (start > 0) {
                return str.substring(start, start + cut);
            } else {
                return str.substring(0, str.length());
            }
        }
    }

    /**
     * 判断是否为空
     * 
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        return str == null || "".equals(str.trim());
    }

    public static String encrypt(String str, String salt) {
        PasswordEncoder encoder = new Md5PasswordEncoder();
        return encoder.encodePassword(str, salt);
    }

    /**
     * 获取随机ID号,例如00c89453-9865-4fb5-a120-7ec6e3eebcaf
     * 
     * @return
     */
    public static String getRandomUUID() {
        return UUID.randomUUID().toString().toUpperCase();
    }

    public static String listToString(List<String> list, char separator) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < list.size(); i++) {
            sb.append(list.get(i));
            if (i < list.size() - 1) {
                sb.append(separator);
            }
        }
        return sb.toString();
    }

    // 格式化字符串，右补0，超出限制长度，则截断
    public static String formatStrLen(String str, Integer limit) {
        Integer difLen = 0;
        StringBuilder nstr = new StringBuilder();

        if (limit > str.length()) {
            difLen = limit - str.length();
            nstr.append(str);
        } else {
            nstr.append(str.substring(0, limit));
        }
        for (int i = 0; i < difLen; i++)
            nstr.append('0');
        return nstr.toString();
    }

    /**
     * 将数据前补零，补后的总长度为指定的长度，以字符串的形式返回
     */
    public static String frontCompWithZore(long data, int formatLength) {
        return String.format("%0" + formatLength + "d", data);
    }

    /*
     * 获取主键ID，根据keyName生成，返回的ID格式为14位 yyyyMMdd + 6位流水号
     */
    public static String getId(String keyName) {
        String ymd = DateUtil.getSystemDateOfY2D();
        return SequenceUtil.getInstance().getId(keyName + ymd, ymd, 6);
    }

    /**
     * 根据名字获取cookie
     * 
     * @param request
     * @param name
     *            cookie名字
     * @return
     */
    public static Cookie getCookieByName(HttpServletRequest request, String name) {
        Map<String, Cookie> cookieMap = readCookieMap(request);
        if (cookieMap.containsKey(name)) {
            return (Cookie) cookieMap.get(name);
        } else {
            return null;
        }
    }

    /**
     * 将cookie封装到Map里面
     * 
     * @param request
     * @return
     */
    private static Map<String, Cookie> readCookieMap(HttpServletRequest request) {
        Map<String, Cookie> cookieMap = new HashMap<String, Cookie>();
        Cookie[] cookies = request.getCookies();
        if (null != cookies) {
            for (Cookie cookie : cookies) {
                cookieMap.put(cookie.getName(), cookie);
            }
        }
        return cookieMap;
    }

    public static final String chars = "abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    public static String generateShortUuid() {
        StringBuffer shortBuffer = new StringBuffer();
        String uuid = UUID.randomUUID().toString().replace("-", "");
        for (int i = 0; i < 8; i++) {
            String str = uuid.substring(i * 4, i * 4 + 4);
            int x = Integer.parseInt(str, 16);
            shortBuffer.append(chars.charAt(x % 0x3E));
        }
        return shortBuffer.toString();
    }
}
